package com.codeyang.service.impl;

import cn.hutool.core.bean.BeanUtil;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.codeyang.domain.Basket;
import com.codeyang.domain.Sku;
import com.codeyang.dto.CartItem;
import com.codeyang.dto.CartMoney;
import com.codeyang.dto.ShopCartResult;
import com.codeyang.feign.CartSkuFeign;
import com.codeyang.mapper.BasketMapper;
import com.codeyang.service.BasketService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import org.springframework.util.ObjectUtils;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 描述: TO-删除标志-DO
 *
 * @author CodeYang_Site
 * @version 2021/5/31 9:45
 */
@Slf4j
@Service
public class BasketServiceImpl extends ServiceImpl<BasketMapper, Basket> implements BasketService {


    @Autowired
    private BasketMapper basketMapper;

    @Autowired
    private CartSkuFeign cartSkuFeign;


    /**
     * 根据用户id查询用户购物车商品数量
     * step:
     * 1. 根据userId 查询 购物车表 basket
     *
     * @param userId
     * @return
     */
    @Override
    public Integer findCartCount(String userId) {
        // SQL select IFNULL(sum(basket_count),0) from basket where user_id='1'
        //mp IFNULL(sum(basket_count),0)  当做一个字段
        List<Object> objects = basketMapper.selectObjs(
                new QueryWrapper<Basket>()
                        .select("IFNULL(sum(basket_count),0)")
                        .eq(Basket.COL_USER_ID, userId)
        );
        return Integer.parseInt(objects.get(0).toString());
    }

    /**
     * 修改购物车商品
     * 根据用户id+skuId 来修改商品数量
     * 增加|减少
     * 前端做了一个 值处理, 是一个正负值的处理,只需要加就完事了
     *
     * @param basket
     */
    @Override
    public void changeCartItem(Basket basket) {
        log.info("修改商品购物车{}", JSON.toJSONString(basket));
        //1.查询购物车商品
        Basket oldBasket = basketMapper.selectOne(
                new LambdaQueryWrapper<Basket>()
                        .eq(Basket::getUserId, basket.getUserId())
                        .eq(Basket::getSkuId, basket.getSkuId())
        );
        //2.判断之前有没有这个对象
        if (ObjectUtils.isEmpty(oldBasket)) {
            //如果之前不存在,那么就新增
            basket.setBasketDate(new Date());
            basketMapper.insert(basket);
            return;
        }
        //3.如果之前存在那么就是修改属性
        int finalCount = oldBasket.getBasketCount() + basket.getBasketCount();

        if (finalCount > 0) {
            //修改属性值
            oldBasket.setBasketDate(new Date());
            oldBasket.setBasketCount(finalCount);
            basketMapper.updateById(oldBasket);
        }
        if (0 == finalCount) {
            // 证明要删除
            basketMapper.deleteById(oldBasket);
            return;
        }
        //负数
        throw new IllegalArgumentException("购物车中商品不能小于0");

    }


    /**
     * 根据登录用户的id查询组装 购物车对象
     * 回显示购物车
     * 1.根据用户的id查询购物车集合
     * 2. 拿到skuIds  远程调用拿到List<Sku>
     * 3. 循环 购物车集合  过滤skus的条件 组装对象
     *
     * @param userId
     * @return
     */
    @Override
    public List<ShopCartResult> findCartInfoByUser(String userId) {
        //0.return 对象
        List<ShopCartResult> results = new ArrayList<>();
        //1.
        List<Basket> basketList = basketMapper.selectList(
                new LambdaQueryWrapper<Basket>()
                        .eq(Basket::getUserId, userId)
        );
        if (CollectionUtils.isEmpty(basketList)) {
            return Collections.emptyList();
        }
        //2.收集skuIds
        List<Long> skuIds = basketList.stream().map(Basket::getSkuId).collect(Collectors.toList());
        //3.远程调用获取sku集合
        List<Sku> skus = cartSkuFeign.getSkusBySkuIds(skuIds);

        if (CollectionUtils.isEmpty(skus)) {
            throw new RuntimeException("服务器维护中");
        }
        // 组装对象 准备
        //创建店铺
        ShopCartResult shopCartResult = new ShopCartResult();
        // 创建商品集合
        List<CartItem> shopCartItems = new ArrayList<>();
        //循环购物车记录组装对象属性
        basketList.forEach(basket -> {
            //1.过滤出属于当前对象的sku集合
            Sku sku1 = skus.stream().filter(sku -> sku.getSkuId().equals(basket.getSkuId())).collect(Collectors.toList()).get(0);
            //创建商品具体对象 拷贝数据信息
            CartItem cartItem = new CartItem();
            BeanUtil.copyProperties(sku1, cartItem, true);
            BeanUtil.copyProperties(basket, cartItem, true);
            //添加到商品集合中
            shopCartItems.add(cartItem);

        });

        shopCartResult.setShopCartItems(shopCartItems);
        //倒序组装
        results.add(shopCartResult);
        return results;
    }

    /**
     * 计算购物车中选中商品的总价
     * 构造对象,关注入参,出参的构造即可
     *
     * @param basketIds
     * @return
     */
    @Override
    public CartMoney calculateCartMoney(List<Long> basketIds) {
        //0.return
        CartMoney cartMoney = new CartMoney();
        BigDecimal finalMoney = BigDecimal.ZERO;
        BigDecimal subtractMoney = BigDecimal.ZERO;
        BigDecimal totalmoney = BigDecimal.ZERO;
        if (CollectionUtils.isEmpty(basketIds)) {
            return cartMoney;
        }
        //根据baskIds查询购物车
        List<Basket> baskets = basketMapper.selectBatchIds(basketIds);
        if (CollectionUtils.isEmpty(baskets)) {
            return cartMoney;
        }
        //都不为0 证明购物车中有商品,需要组装计算
        //1.拿出 skuids
        List<Long> skuIds = baskets.stream().map(Basket::getSkuId).collect(Collectors.toList());
        //2.根据skuIds 查询DB得到sku实体集合

        List<Sku> skus = cartSkuFeign.getSkusBySkuIds(skuIds);

        if (!CollectionUtils.isEmpty(skus)) {
            ArrayList<BigDecimal> totalMoneyList = new ArrayList<>();
            //不为空,计算 商品总金额,最终金额,折扣策略
            //循环购物车实体记录
            baskets.forEach(basket -> {
                //过滤出属于当前 购物车的sku记录
                Sku sku1 = skus
                        .stream()
                        .filter(sku -> sku.getSkuId().equals(basket.getSkuId()))
                        .collect(Collectors.toList()).get(0);
                //拿到商品价格,-最终目的
                BigDecimal price = sku1.getPrice();
                //拿到当前记录的商品数量
                Integer basketCount = basket.getBasketCount();
                //当前商品的价格 price*count = totalPrice
                BigDecimal nowTotalPrice = price.multiply(new BigDecimal(basketCount));
                totalMoneyList.add(nowTotalPrice);
            });
            //计算总金额
            totalmoney = totalMoneyList.stream().reduce(BigDecimal::add).get();
            //计算总数量
            Integer totalCount = baskets.stream().map(Basket::getBasketCount).reduce(Integer::sum).get();
            //

            //判断是否需要付运费 满99不需要付
            if (totalmoney.compareTo(new BigDecimal(99)) < 0) {
                //没满+6元
                finalMoney = totalmoney.add(new BigDecimal(6));
            } else {
                //>99 就是原价
                finalMoney = totalmoney;
            }
        }
        //倒序锁定
        cartMoney.setFinalMoney(finalMoney);
        cartMoney.setTotalMoney(totalmoney);
        //折扣暂时不设置 就是0
        cartMoney.setSubtractMoney(subtractMoney);
        return cartMoney;
    }
}
